Use compilation jobs for caching and shared reflection - #311

PTX is an implementation detail of `tileiras`, read from an undocumented CUBIN
section; `code_ptx`/`@device_code_ptx` say so and go away with it.

cuTile's `@device_code_sass` duplicated `CUDA.@device_code_sass` with a narrower
scope (only cuTile kernels, by recompiling each signature). The CUDA macro
already shows every loaded module, cuTile's included; `code_sass` remains for
inspecting a signature without a device or under a profiler.

The `@device_code_*` hook now fires once from the launch's compile entry point
rather than from inside the cached emit chain, so the chain checks its own
cached field before recursing and subprogram compilation needs no hook
suppression.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNHajvrhhKBBUF7w6cDiKr

Share inference across targets and hints, storing compiled binaries per
configuration on the generic or constant-specialized inference result.
Cache loaded kernels per CUDA context and synchronize result publication
without holding a lock during compilation or module loading.

Pass the launch job to task-scoped reflection hooks so inspection preserves
its target, constants, and options, including on cache hits.

Co-authored-by: Tim Besard <tim.besard@gmail.com>

cuTile keeps its own compiler, but reports compilations through
GPUCompiler.compile_hook instead of a hook of its own, and builds its
@device_code_* macros on GPUCompiler.emit_hooked_compilation. TileJob
implements GPUCompiler.code_typed and code_warntype, so GPUCompiler's (and
CUDA.jl's) @device_code_typed and @device_code_warntype observe cuTile
launches too, mixed-backend expressions included.

Requires GPUCompiler 2.6 for the backend-agnostic hook.

With compilations reported through the shared hook, the Julia-level stages
need no cuTile-specific macros: re-export GPUCompiler's, which behave like
their CUDA.jl counterparts (@device_code_typed returns a dictionary from job
to typed code), and keep cuTile's own macros for its own stages.

Display warntype from the inferred TileJob source, including constant arguments. Let CUDA PTX reflection dispatch to cuTile, and filter non-Tile jobs from cuTile-specific stage macros.

Test constant-specialized reflection and warm mixed CUDA/cuTile launches through the shared macros.

`code_typed(f, argtypes)` and `code_structured(f, argtypes)` built a
`TileJob`, whose default bytecode version probes `tileiras`, before
running inference. Without target keywords these stages only need the
inferred code, so run inference directly and leave the job to the
target-dependent stages. Neither a device nor `tileiras` is needed for
them anymore.